module klang.编译.注册.注册_;
import 全局;
import klang.编译.核心.核心_: 词典_;
import klang.编译.类型.枚举值.枚举值_: TK;
import klang.编译.类型.类型_: 前端接口_;
import klang.编译.语法节点.节点_: 节点_, 令牌_, 令牌种类_, 节点数组_, 增量节点_, 源文件_, 创建节点;
import klang.编译.json.JSON: JSON值_;
alias 初始化函数_ = void delegate();
alias 启动函数_ = int delegate(dstring[]);
前端接口_ 当前前端;
词典_!(klang.编译.注册.注册_.初始化函数_) _注册的初始化函数;
词典_!(klang.编译.注册.注册_.启动函数_) _注册的启动函数;
TK _当前前端目标;
词典_!(TK) _已经注册的前端目标;
前端接口_[] _注册的前端;
TK _获取语言的前端目标(dstring 语言id) {
    switch (语言id) {
        case "klang"d: {
            return TK.Klang;
        }
        case "json"d: {
            return TK.Json;
        }
        case "ir"d: {
            return TK.Ir;
        }
        default: {
            return TK.无_;
        }
    }
}
bool 注册初始化函数(dstring 语言id, 初始化函数_ 初始化) {
    if ((._注册的初始化函数 is null) || (._注册的初始化函数.原型 is ··null!(初始化函数_[dstring]))) {
        ._注册的初始化函数 = new 词典_!(初始化函数_)();
    }
    if (!_注册的初始化函数.具有(语言id)) {
        _注册的初始化函数.p·设置(语言id, cast(初始化函数_)(初始化));
        return true;
    }
    return false;
}
bool 注册启动函数(dstring 语言id, 启动函数_ 启动函数) {
    if ((._注册的启动函数 is null) || (._注册的启动函数.原型 is ··null!(启动函数_[dstring]))) {
        ._注册的启动函数 = new 词典_!(启动函数_)();
    }
    if (!_注册的启动函数.具有(语言id)) {
        _注册的启动函数.p·设置(语言id, cast(启动函数_)(启动函数));
        return true;
    }
    return false;
}
初始化函数_ 获取初始化函数(dstring 语言id) {
    if ((._注册的初始化函数 is null) || (._注册的初始化函数.原型 is ··null!(初始化函数_[dstring]))) {
        return ··null!(初始化函数_);
    }
    if (_注册的初始化函数.具有(语言id)) {
        return _注册的初始化函数.获取(语言id);
    }
    return ··null!(初始化函数_);
}
启动函数_ 获取启动函数(dstring 语言id) {
    if ((._注册的启动函数 is null) || (._注册的启动函数.原型 is ··null!(启动函数_[dstring]))) {
        return ··null!(启动函数_);
    }
    if (_注册的启动函数.具有(语言id)) {
        return _注册的启动函数.获取(语言id);
    }
    return ··null!(启动函数_);
}
TK 注册前端语言(dstring 语言id) {
    if ((._已经注册的前端目标 is null) || (._已经注册的前端目标.原型 is ··null!(TK[dstring]))) {
        ._已经注册的前端目标 = new 词典_!(TK)();
    }
    if (_已经注册的前端目标.具有(语言id)) {
        return _已经注册的前端目标.获取(语言id);
    }
    TK id = ._获取语言的前端目标(语言id);
    _已经注册的前端目标.p·设置(语言id, id);
    return id;
}
TK 获取注册的前端id(dstring 语言id) {
    if ((._已经注册的前端目标 is null) || (._已经注册的前端目标.原型 is ··null!(TK[dstring]))) {
        return TK.无_;
    }
    if (.语言id已经注册(语言id)) {
        return _已经注册的前端目标.获取(语言id);
    }
    return TK.无_;
}
bool 语言id已经注册(dstring 语言id) {
    if ((._已经注册的前端目标 is null) || (._已经注册的前端目标.原型 is ··null!(TK[dstring]))) {
        return false;
    }
    return _已经注册的前端目标.具有(语言id);
}
前端接口_ 获取注册的前端(TK 前端id) {
    if (._注册的前端 is ··null!(前端接口_[])) {
        ._注册的前端 = [];
    }
    if (前端id < _注册的前端.length) {
        return _注册的前端[(cast(int)(前端id))];
    }
    return ··null!(前端接口_);
}
void 注册前端(前端接口_ 前端) {
    int id = (cast(int)(前端.获取前端目标()));
    if (._注册的前端 is ··null!(前端接口_[])) {
        ._注册的前端 = [];
    }
    if (_注册的前端.length <= id) {
        _注册的前端.length = id + 1;
    }
    _注册的前端[id] = 前端;
}
前端接口_ 获取注册前端且执行初始化(dstring 语言id) {
    初始化函数_ 初始化 = .获取初始化函数(语言id);
    if (初始化 !is ··null!(初始化函数_)) {
        初始化();
        TK id = .获取注册的前端id(语言id);
        return .获取注册的前端(id);
    }
    return ··null!(前端接口_);
}
// 启动后方可调用
前端接口_ 获取注册的前端通过前端目标(TK 语言目标) {
    return .获取注册的前端(语言目标);
}
// 启动后方可调用
前端接口_ 获取注册的前端通过语言id(dstring 语言id) {
    TK id = .获取注册的前端id(语言id);
    return .获取注册的前端(id);
}
